﻿<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
	<head>
		<meta charset="utf-8"/>
		<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
		<title>Основные инструкции в языке Python</title>

		<link rel="stylesheet" type="text/css" href="http://moodle.spb.ru/file.php/84/python/standby.css"/><!-- page style: default -->
	</head>
	<body>
		<div class='page'>
			<h2>Основные инструкции в языке Python</h2>
			<p>
				В прошлом уроке мы не коснулись ещё одной темы, касающейся типов данных. Как уже говорилось ранее, Python - язык с динамической типизацией. В приведённых примерах вы нигде не могли встретить объявление типа переменной - он определялся автоматически интерпретатором в момент присваивания значения. Это позволяет без каких-либо проблем выполнять, например, следующий код:
				<code>
					<span style="color: #000000;">
						a = 5<br/>
						a = "5"<br/>
					</span>
				</code>
			</p>
			<p>
				После выполнения первой строчки, имя a будет связано со значением типа <cite>int</cite>, но последующая строка связывает это имя со значением уже другого типа - <cite>str</cite>. Никаких ошибок выведено при этом не будет. Это добавляет определённые проблемы при разработке, когда нам важно, чтобы какое-либо имя было всегда связано со значением одного единственного типа.
			</p>
			<p>
				Другой пример: вам необходимо считать из файла числовые значения, но, вместо значений типа <cite>int</cite>, вы получаете строки. Хотя эти строки и содержат числа, просто так умножать и складывать их не получится (и вообще работать как с числами).
			</p>
			<p>
				Очевидно, что нам не обойтись без операций для приведения типов, чтобы избавится от проблем первого и второго примеров (и не только их).
			</p>
			<h3>Приведение типов</h3>
			<p>
				В Python'е привидение типов реализовано через встроенные функции. Чтобы привести значение одного типа к значению второго типа, необходимо вызвать встроенную функцию с именем второго типа и передать в нее первое значение.
			</p>
			<p>
				Для привидения к встроенным типам (кроме <cite>NoneType</cite>) есть следующие функции:
			</p><br/>
			<p>
				<b>bool(x)</b> - приводит значение <cite>x</cite> к типу <cite>bool</cite>. На прошлом уроке уже рассказывалось, как остальные типы приводятся к <cite>bool</cite>: <cite>None</cite>, нулевые числа (<cite>0</cite>, <cite>0.0</cite>, <cite>0j</cite>), пустые последовательности (<cite>''</cite>, <cite>[]</cite>, <cite>()</cite>, <cite>{}</cite>) - это всегда <cite>False</cite>. В остальных случаях - значения приводятся к <cite>True</cite>. Если же приводить значения типа <cite>bool</cite>, оно, естественно, не изменится:
				<code>
					<span style="color: #000000;">	
						bool(<span style="color: #0000FF;">True</span>)   <span class="comment"># True</span><br/>
						bool(0)      <span class="comment"># False</span><br/>
						bool(<span style="color: #0000FF;">None</span>)   <span class="comment"># False</span><br/>
						bool(' ')    <span class="comment"># True, строка - не пустая</span><br/>
						bool({})     <span class="comment"># False</span><br/>
						bool({1:1})  <span class="comment"># True	</span><br/>
					</span>
				</code>
			</p>	
			<p>
				<b>int(x)</b> - приводит значение <cite>x</cite> к типу <cite>int</cite>. В качестве аргумента можно передавать булевое значение, целые и вещественные числа (<cite>float</cite>), а также строки. Остальные типы нельзя приводить к целым числам. Числа с плавающей точкой преобразуются в целые за счёт отсечения дробной части. Для округления нужно использовать другую функцию.
				<code>
					<span style="color: #000000;">
						int(<span style="color: #0000FF;">True</span>)     <span class="comment"># 1</span><br/>
						int(<span style="color: #0000FF;">False</span>)    <span class="comment"># 0</span><br/>
						int("567")    <span class="comment"># 567 - целое число</span><br/>
						int("567a")   <span class="error"># Ошибка, в строке недопустимый символ</span><br/>
						int(0.25)     <span class="comment"># 0 - исчезла дробная часть</span><br/>
						int(1 + 0.5j) <span class="error"># Ошибка, комплексное число в int не преобразуется</span><br/>
					</span>
				</code>
			</p>
			<p>
				<b>float(x)</b> - приводит значение <cite>x</cite> к типу <cite>float</cite>. Работа этой функции идентична <cite>int(x)</cite>, только, разве что, результат будет всегда числом с плавающей точкой.
				<code>
					<span style="color: #000000;">
						float(<span style="color: #0000FF;">True</span>)     <span class="comment"># 1.0</span><br/>
						float(<span style="color: #0000FF;">False</span>)    <span class="comment"># 0.0</span><br/>
						float("567")    <span class="comment"># 567.0</span><br/>
						float("567a")   <span class="error"># Ошибка, в строке недопустимый символ</span><br/>
						float(5)        <span class="comment"># 5.0</span><br/>
						float(1 + 0.5j) <span class="error"># Ошибка</span><br/>
					</span>
				</code>
			</p>
			<p>
				<b>complex(x, y)</b> - приводит числовое, булевое или строковое значение <cite>x</cite> к типу <cite>complex</cite>. Второй параметр функции <cite>y</cite> не обязательный, но таким образом можно указывать отдельно реальную часть числа и мнимую. В этом случае <span class="important">оба параметра должны быть числовыми</span>, иначе интерпретатор выдаст ошибку.
				<code>
					<span style="color: #000000;">
						complex(1)           <span class="comment"># (1 + 0j)</span><br/>
						complex(1, 2.5j)     <span class="comment"># (1 + 2.5j)</span><br/>
						complex('1+1.5j')    <span class="comment"># (1 + 1.5j)</span><br/>
						complex(<span style="color: #0000FF;">True</span>, <span style="color: #0000FF;">False</span>) <span class="comment"># (1 + 0j)</span><br/>
						complex(1, '2j')     <span class="error"># Ошибка</span><br/>
						complex(<span style="color: #0000FF;">False</span>, 3)    <span class="comment"># (0 + 3j)</span><br/>
					</span>
				</code>
			</p>
			<p>
				<b>str(x)</b> - преобразует значение в строку. В качестве <cite>x</cite> можно передавать любое значение:
				<code>
					<span style="color: #000000;">
						str(<span style="color: #0000FF;">None</span>)                    <span class="comment"># 'None'</span><br/>
						str(5)                       <span class="comment"># '5'</span><br/>
						str(1+0.5j)                  <span class="comment"># '(1+0.5j)'</span><br/>
						str([1, 2, 3,])              <span class="comment"># '[1, 2, 3]'</span><br/>
						str((1, 2, 3))               <span class="comment"># '(1, 2, 3)'</span><br/>
						str(<span style="color: #0000FF;">True</span>)                    <span class="comment"># 'True'</span><br/>
						str({ 1: "one", 2: "two" })  <span class="comment"># "{1: 'one', 2: 'two'}"</span><br/>
					</span>
				</code>
			</p>
			<p><b>list(x)</b> служит для преобразования последовательностей в список. В качестве <cite>x</cite> можно передавать строки, кортежи, другие списки, словари. Строки преобразуются в список посимвольно. Словари преобразуются в список, который будет содержать только ключи.</p>
			<code>
				<span style="color: #000000;">
					list('abc')                         <span class="comment"># ['a', 'b', 'c']</span><br/>
					list([1, 2, 3])                     <span class="comment"># [1, 2, 3]</span><br/>
					list((1, 2, 3))                     <span class="comment"># [1, 2, 3]</span><br/>
					list({1: 1.0, '2': 2, <span style="color: #0000FF;">True</span>: <span style="color: #0000FF;">False</span>}) <span class="comment"># [1, '2', True]</span><br/>
				</span>
			</code>
			<p>
				<b>tuple(x)</b> работает также, как и <cite>list(x)</cite>, только на выходе мы получаем кортеж - неизменяемый список.
				<code>
					<span style="color: #000000;">
						tuple('abc')                         <span class="comment"># ('a', 'b', 'c')</span><br/>
						tuple([1, 2, 3])                     <span class="comment"># (1, 2, 3)</span><br/>
						tuple((1, 2, 3))                     <span class="comment"># (1, 2, 3)</span><br/>
						tuple({1: 1.0, '2': 2, <span style="color: #0000FF;">True</span>: <span style="color: #0000FF;">False</span>}) <span class="comment"># (1, '2', True)</span><br/>
					</span>
				</code>
			<p>
				<b>dict(x)</b> преобразует объект <cite>x</cite> в словарь. Здесь на аргумент накладываются серьёзные ограничения. Во-первых, это должна быть последовательность (не строка), то есть можно преобразовывать только типы <cite>tuple</cite> и <cite>list</cite>. Во-вторых, каждый элемент этой последовательности должен являться парой ключ-значение в виде списка или кортежа (нужно помнить, что в качестве ключа не могут выступать списки, словари или кортежи их содержащие):
				<code>
					<span style="color: #000000;">
						dict([(5, "five"), (6, "six")]) <span class="comment"># {5: "five", 6: "six"}</span><br/>
						dict(([1, 100], [2, 200])) 	<span class="comment"># {1: 100, 2: 200}</span><br/>
						dict(([1, 100], (6, "six"))) 	<span class="comment"># {1: 100, 6: "six"}</span><br/>
					</span>
				</code>
			</p>
			<p>
				Стоит отметить, что эти функции могут и не принимать никаких аргументов, тогда они вернут <cite>False</cite>, нулевое число или пустую последовательность.
				<code>
					<span style="color: #000000;">	
						bool()    <span class="comment"># False</span><br/>
						int()     <span class="comment"># 0</span><br/>
						float()   <span class="comment"># 0.0</span><br/>
						complex() <span class="comment"># 0j</span><br/>
						str()     <span class="comment"># ''</span><br/>
						list()    <span class="comment"># []</span><br/>
						tuple()   <span class="comment"># ()</span><br/>
						dict()    <span class="comment"># {}</span><br/>
					</span>
				</code>
			</p>
			<h3>Некоторые полезные функции</h3>
			<p>
				При работе с последовательностями и не только будет полезным знать следующие функции.
			</p><br/>
			<p>
				<b>len(s)</b> - вернёт длину последовательности <cite>s</cite>. Естественно, эту функцию нужно использовать для строк, списков, кортежей и словарей:
				<code>
					<span style="color: #000000;">	
						len(['a', 3, <span style="color: #0000FF;">True</span>]) 		<span class="comment"># 3</span><br/>
						len("Hello!") 			<span class="comment"># 6</span><br/>
						len({1: "one", 2: "two"}) 	<span class="comment"># 2</span><br/>
					</span>
				</code>
			</p>
			<p>
				<b>max(s)</b>, <b>min(s)</b> - возвращают максимальный и минимальный элемент последовательности <cite>s</cite> соответственно. Для строк сравнение происходит по коду символа. Для кортежей будет возвращен минимальный или максимальный элемент из ключей словаря.
				<code>
					<span style="color: #000000;">	
						max('sabcde')               <span class="comment"># 's'</span><br/>
						min('sabcde')               <span class="comment"># 'a'</span><br/>
						max([8, 3, 5, 2, 1, 0, 5])  <span class="comment"># 8</span><br/>
						min({5:5, 2:2, 7:7})        <span class="comment"># 2</span><br/>
					</span>
				</code>
			</p>
			<p>
				<span class="important"><b>print()</b> - функция, которая выводит на печать произвольное количество аргументов</span>. Передаваемые аргументы должны разделятся запятой. Функция попробует преобразовать каждый из них в строку и вывести последовательно через пробел с переходом на новую строку после последнего элемента.
				<code>
					<span style="color: #000000;">	
						print(1)                     <span class="comment"># Будет выведено 1</span><br/>
						print(1, 2)                  <span class="comment"># 1 2</span><br/>
						print(1, '2', <span style="color: #0000FF;">True</span>, [], ())  <span class="comment"># 1 2 True [] ()	</span><br/>		
					</span>
				</code>
			</p>
			<h3>Основные инструкции</h3>
			<p>
				Чтобы лучше познакомится с синтаксическими особенностями языка, различными синтаксическими конструкциями, вроде ветвления, блоков, циклов, мы будем писать не в интерактивном режиме IDLE, а в отдельный файл с расширением <cite>.py</cite>.
			</p>
			<p>
				Чтобы создать такой файл, в IDLE зайдите в пункт меню <span class="important">File - New Window</span> или нажмите комбинацию клавиш <cite>Ctrl+N</cite>. Появится новое окно без всяких приглашений, где можно набрать код программы целиком.
			</p>
			<p>
				Введите команду <cite>import this</cite>, или любую другую. Теперь нам нужно проверить, что наша программа работает. Сделать это можно через пункт меню <span class="important">Run - Run Module</span> (или клавиша <cite>F5</cite>). IDLE нам сообщит, что перед запуском программы ее нужно сохранить. Сохраните данный файл с расширением <cite>.py</cite>. Когда вы это сделаете, откроется окно IDLE с интерактивным режимом (если оно закрыто), где будет выведен результат работы программы (или не выведен, если программа ничего не выводит).
			</p><br/>
			<p>
				Для работы с последовательностями и именами, уже связанными с определёнными значениями, существует специальная <span class="important">инструкция <b>del</b></span> (сокращено от <i>delete</i>). В случае применения этой инструкции к имени-идентификатору, <cite>del</cite> разрывает связь этого имени со своим значением *:
			</p>
			<div class="note">
				<p>
					Писать команды нужно точно так же, как они приведены в листинге, то есть каждая новая команда - на новой строчке, нет разделителей вида <cite>;</cite>. Дальше будет объяснено, почему нужно так делать.
				</p>
			</div>
			<code>
				<span style="color: #000000;">	
					<span class="comment">
						# Когда интерпретатор дойдет до строк с ошибкой, он выведет<br/>
						# текст ошибки на экран и прекратит выполнение программы,<br/>
						# поэтому после того, как вы убедитесь, что <br/>
						# данные команды действительно ошибочны, нужно их <br/>
						# закомментировать и запустить программу заново (F5)
					</span><br/>
					a = 5<br/>
					<span style="color: #0000FF;">del</span> a<br/>
					print(a)      <span class="error"># Ошибка, имя a не определено</span><br/><br/>
					<span class="comment"># Важный момент</span><br/>
					l1 = [1, 2]<br/>
					l2 = l1       <span class="comment"># l2 ссылается на тот же объект, что и l1 </span><br/>
					<span style="color: #0000FF;">del</span> l1<br/>
					print(l1)     <span class="error"># Ошибка, имя l1 не определено</span><br/>
					print(l2)     <span class="comment"># [1, 2]</span><br/>
				</span>
			</code>	
			<p>
				Как уже было сказано, <cite>del</cite> можно применять к последовательностям для удаления какого-либо элемента или среза (сразу нескольких значений):
				<code>
					<span style="color: #000000;">	
						s = [1, 2, 3, 4, 5, 6, 7]<br/>
						<span style="color: #0000FF;">del</span> s[3]	  <span class="comment"># Удаляем 4-й элемент из списка</span><br/>
						<span style="color: #0000FF;">del</span> s[::2]	  <span class="comment"># Удаляем срез</span><br/>
						print(s)	  <span class="comment"># [2, 5, 7]</span><br/>
						d = {1: "one", 2: "two", 3: "three"}<br/>
						<span style="color: #0000FF;">del</span> d[2]	  <span class="comment"># Удаляем значение из словаря по ключу</span><br/>
						print(d)	  <span class="comment"># {1: "one", 3: "three"}	</span><br/>		
					</span>
				</code>
			</p>
			<div class="note">
				<p>
					Как было сказано выше, <cite>del</cite> не удаляет объект из памяти. Он лишь разрывает связь имени с объектом.
				</p>  
				<p>
					В C\C++ нужно было очень внимательно следить за всей выделенной памятью, и когда объект становился ненужным, следовало очищать занятую им память. Процесс этот довольно трудный: делалось это вручную, из-за чего достаточно часто возникали различные ошибки. Например, объект был уже удален, а к нему пытаются обратиться.
				</p>
				<p>
					Поэтому в многих современных языках этот процесс был автоматизирован. В них присутствует так называемый <b>сборщик мусора</b>, который следит за тем, чтобы ненужные объекты не занимали место в памяти. В Python'е тоже есть сборщик мусора. Как он работает? Если говорить в общих чертах, то он просто проверяет, ссылаются ли какие-нибудь имена в программе на объекты в памяти. Если таких имен нет, то тогда объект считается ненужным и он удаляется. Что логично, ведь если потеряны все ссылки на объект, то до объекта уже не добраться.
				</p>
				<p>
					Инструкция <cite>del</cite> разрывает связь имени с объектом. Когда сборщик мусора срабатывает (чаще всего это происходит когда интерпретатор покидает текущую область видимости) и если с данным объектом не связано ни одного имени, то он его удаляет. Стоит отметить, что когда интерпретатор выходит из области видимости, например, функции, то и все локальные ссылки удаляются, а, следовательно, и объекты в памяти. <span class="important">Это означает, что пользоваться инструкцией <cite>del</cite> для разрыва связи между именем и объектом не обязательно</span>. Поэтому чаще всего <cite>del</cite> используют для удаления элементов или срезов из списков и значений из словарей.
				</p>
			</div>
			<br/>
			<p>
				Пока что мы вводили простые программы, состоящие из нескольких операторов - набора операций и операндов. Как вы уже, наверное, поняли, <span class="important"><b>операторы разделяются друг от друга символом перехода на новую строку</b></span>.
			</p>
			<p>
				В языках, которые вам известны, существует понятия блока кода. В языке Pascal блоком кода считался набор операторов, заключённых между ключевыми словами <cite>Begin</cite> и <cite>End</cite>. В языке C блок кода заключался в фигурные скобки <cite>{ ... }</cite>.
			</p>
			<p>
				Так как в Python'е фигурные скобки заняты (для объявления словаря), а <cite>Begin</cite> и <cite>End</cite> не являются ключевыми словами языка, и не только поэтому, конечно, <span class="important"><b>блок кода выделяется отступами</b></span>. Да, верно, если вы хотите выделить несколько операторов в один блок, каждый оператор должен содержать в начале строки один и тот же отступ.
			</p>
			<p>
				В качестве отступа можно использовать несколько пробелов или символов табуляции, однако <span class="important">рекомендуется использовать 4 пробела</span> (в редакторе кода IDLE символ табуляции заменяется именно 4-мя пробелами).
			</p><br/>
			<p>
				<span class="important">Непосредственно вставить один блок кода в другой нельзя</span>. Это можно сделать только в случае наличия управляющих конструкций, о которых мы поговорим позже.
			</p>
			<p>
				Сравните читаемость кода написанного на C, и код Python'а. Здесь важно понимать то, что таких однострочных монстров написать на Python'е не получится:
			</p><br/>
			<p>
				<cite>int main(int c,char**v){return!m(v[1],v[2]);}m(char*s,char*t){return *t-42?*s?63==*t|*s==*t&amp;&amp;m(s+1,t+1):!*t:m(s,t+1)||*s&amp;&amp;m(s+1,t);}</cite>
			</p><br/>
			<p>
				Конечно, так мало кто пишет, но, тем не менее, такое написание программ не запрещено. Python <u>не позволяет</u> так писать.
			</p><br/>
			<p>
				<span class="important">Оператор условия <b>if</b></span> разветвляет выполнение программы в зависимости от значения выражения, условия оператора. Данный оператор имеет следующий синтаксис:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">if</span> <i>условие</i>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<i>блок кода</i><br/>
					</span>
				</code>
			</p>
			<p>
				Заметьте, что после условия стоит символ двоеточия. Его обязательно нужно ставить, когда мы начинаем новый блок кода. Так же заметьте, что новый блок кода имеет отступ. И все операторы данного блока должны иметь одинаковый отступ. Например:
				<code>
					<span style="color: #000000;">
						<span class="comment"># у нас есть a - целое число</span><br/>
						<span style="color: #0000FF;">if</span> a > 0:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;b = a<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(b)<br/>
					</span>
				</code>
			</p>
			<p>
				Если a было больше нуля, то тогда новой переменной будет присвоено значение a, а потом новая переменная будет выведена на экран.
			</p>
			<p>
				Так же как и в других языках, оператор ветвления имеет ветвь <cite>else</cite>. Блок кода стоящий за ней выполнится только тогда, когда условие ложно:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">if</span> a > 0:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;b = a<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(b)<br/>
						<span style="color: #0000FF;">else</span>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(a)<br/>
					</span>
				</code>
			</p>
			<p>
				Так же как и в других языках все управляющие конструкции можно вкладывать друг в друга:
				<code>
					<span style="color: #000000;">
						<span class="comment"># Нахождение корней квадратного уравнения</span><br/>
						a, b, c = 3.0, 4.0, 5.0<br/>
						<span style="color: #0000FF;">if not</span> a:      <span class="comment"># Данную строчку можно записать как a == 0</span><br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">if not</span> b: <span class="comment"># b == 0</span><br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">if not</span> c: <br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print('Бесконечно много корней')<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">else</span>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print("Корней нет")<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">else</span>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print('Корень %f' %(-c / b))<br/>
						<span class="comment"># Далее идет, блок кода вычисляющий дискриминант<br/>
						# и выводящий корни</span>
					</span>
				</code>
			</p>
			<p>
				Но <cite>if</cite> в Python'е имеет одно отличие от <cite>if</cite> в других языках: он имеет еще одну ветку помимо <cite>else</cite>. Эта ветка - <cite>elif</cite> - является своего рода заменой для еще одного <cite>if</cite>, вложенного в ветку <cite>else</cite>. И название она получила от слияния <cite>else</cite> и <cite>if</cite> - <cite>elif</cite>. Она используется, когда нужно проверить множество условий и стоит всегда перед веткой <cite>else</cite>:
				<code>
					<span style="color: #000000;">
						weekday = 3<br/>
						<span style="color: #0000FF;">if</span> weekday == 1:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('Понедельник')<br/>
						<span style="color: #0000FF;">elif</span> weekday == 2:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('Вторник')<br/>
						<span style="color: #0000FF;">elif</span> weekday == 3:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('Среда')<br/>
						<span style="color: #0000FF;">elif</span> weekday == 4:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('Четверг')<br/>
						<span style="color: #0000FF;">elif</span> weekday == 5:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('Пятница')<br/>
						<span style="color: #0000FF;">elif</span> weekday == 6:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('Суббота')<br/>
						<span style="color: #0000FF;">elif</span> weekday == 7:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('Воскресенье')<br/>
						<span style="color: #0000FF;">else</span>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('Ошибка!')<br/>
						<br/>
						<span class="comment"># Ошибка в синтаксисе, elif стоит после else</span><br/>
						<span style="color: #0000FF;">if</span> 1 > 2:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('1 > 2')<br/>
						<span style="color: #0000FF;">else</span>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('else')<br/>
						<span style="color: #0000FF;">elif</span>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print('elif')<br/>
					</span>
				</code>
			</p>
			<p>
				Таким образом, конструкция <cite>if.. elif... else</cite> может играть роль переключателя <cite>switch</cite> в языке C, так как в самом Python'е нет инструкции для множественного выбора.
			</p><br/>
			<p>
				Следующая важная инструкция - <span class="important">это инструкция <b>pass</b></span> (переводится, как "пропуск"). Эта инструкция <u>ничего не делает</u>:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">pass</span> <span class="comment"># Ничего не произойдет</span><br/>
					</span>
				</code>
			</p>
			<p>
				Но, тем не менее, она очень важна: чаще всего ее использует в качестве "заглушки", когда никакой инструкции еще нет, но она требуется синтаксисом.
				<code>
					<span style="color: #000000;">
						<span class="comment"># Здесь много кода, работоспособность которого нужно проверить</span><br/>
						<span style="color: #0000FF;">if</span> <i>большое_условие</i>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># Комметарии, как мы знаем, интерпретатор игнорирует</span><br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span class="comment"># то есть комментарии блок кода не формируют</span><br/>
						<span class="comment"># Необходимо сейчас проверить код до if'а</span><br/>
						<span class="error"># Программа не запуститься - ошибка в синтаксисе</span><br/>
						<span class="comment"># Ставим pass</span><br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">pass</span> <br/>
						<span class="comment"># Теперь никакой ошибки нет	</span>	<br/>	
					</span>
				</code>
			</p><br/>
			<p>
				Ещё одной алгоритмической конструкцией является цикл. С помощью них, как вам уже известно, можно описать повторяющиеся действия. Одним из видов цикла является <span class="important">цикл с предусловием - <b>while</b></span>. Тело цикла будет выполнятся до тех пор, пока выражение, составляющее заголовок цикла истинно:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">while</span> <i>выражение</i>: <br/>
						&nbsp;&nbsp;&nbsp;&nbsp;блок кода<br/>
					</span>
				</code>
			</p>
			<p>
				В Python, как и в языке C, выражение представляет из себя логическое значение, которое несёт каждый объект. В качестве выражения мы можем использовать, например, одно единственное число. Если оно равно 0, то тело цикла никогда не выполнится, если оно отлично от 0, то мы получим бесконечный цикл:
				<code>
					<span style="color: #000000;">
						n = 1<br/>
						<span class="comment"># Цикл будет бесконечно выводит сообщения одного вида</span><br/>
						<span style="color: #0000FF;">while</span> 1:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print("строка номер %d" % n)<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;n = n + 1<br/>
						<br/>
						<span class="comment"># Данный цикл завершится, когда значение n станет равным 10</span><br/>
						<span style="color: #0000FF;">while</span> n &lt; 10:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print("n =", n)<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print("n ^ 2 =", n**2)<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;n = n + 1<br/>
					</span>
				</code>
			</p>
			<p>
				Особенностью языка Python в случае с циклами является наличие у них ветки <cite>else</cite>, как и у оператора ветвления. Блок кода, записанный после <cite>else</cite>, выполнится тогда, когда условие цикла станет ложным. Блок <cite>else</cite> выполнится один раз, после чего управление перейдёт к следующей за циклом строчке блока, расположенного уровнем выше:
				<code>
					<span style="color: #000000;">
						n = 1<br/>
						<span style="color: #0000FF;">while</span> n &lt; 10:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print("итерация", n)<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;n = n + 1<br/>
						<span style="color: #0000FF;">else</span>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print("цикл завершён. n =", n) <span class="comment"># n = 10</span><br/>
						print(n)	<span class="comment"># 10</span><br/>
					</span>
				</code>
			</p><br/>			
			<p>
				Другой разновидностью цикла, представленной в языке Python, является <span class="important">цикл <b>for</b></span>. Данный цикл выполняет свой блок кода для каждого элемента последовательности. У цикла <cite>for</cite> в языке Python несколько больше возможностей чем у цикла <cite>for</cite> в языке C. Можно сказать, что цикл <cite>for</cite> в Python похож на <cite>foreach</cite> (для каждого) конструкцию в других языках программирования:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">for</span> <i>элемент</i> <span style="color: #0000FF;">in</span> <i>последовательность</i>:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<i>блок кода</i><br/>
					</span>
				</code>
			</p>
			<p>
				В качестве элемента можно использовать любой идентификатор-имя. Естественно, это имя ранее могло быть и не объявлено вовсе, однако последовательность должна задаваться литералом, существующим именем или функцией, возвращающей последовательность в качестве результата:
				<code>
					<span style="color: #000000;">
						s = [0, 1, 2, 3, 4]<br/>
						<span style="color: #0000FF;">for</span> i <span style="color: #0000FF;">in</span> s :<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">for</span> j <span style="color: #0000FF;">in</span> [0, 1, 2, 3, 4]:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print("i * j = %d" % (i * j))<br/>
					</span>
				</code>
			</p>
			<p>
				Чтобы сделать цикл <cite>for</cite> в Python похожим на тот, что мы использовали в языке C, нужно рассмотреть специальную функцию <cite><b>range(start, end, step)</b></cite>. Данная функция возвращает особую последовательность из целых чисел - от <cite>start</cite>, до <cite>end</cite> (не включая) с шагом <cite>step</cite>. Первый и последний параметр не являются обязательными, тогда начинаться последовательность будет с 0 а шаг будет равным 1. Предыдущий пример можно переписать с использованием этой функции:
				<code>
					<span style="color: #000000;">
						<span style="color: #0000FF;">for</span> i <span style="color: #0000FF;">in</span> range(3):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;<span style="color: #0000FF;">for</span> j <span style="color: #0000FF;">in</span> range(1, 4):<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;print("%d * %d = %d" % (i, j, i * j))<br/><br/>
						<span class="comment"># 0 * 1 = 0</span><br/>
						<span class="comment"># 0 * 2 = 0</span><br/>
						<span class="comment"># 0 * 3 = 0</span><br/>
						<span class="comment"># 1 * 1 = 1</span><br/>
						<span class="comment"># 1 * 2 = 2</span><br/>
						<span class="comment"># 1 * 3 = 3</span><br/>
						<span class="comment"># 2 * 1 = 2</span><br/>
						<span class="comment"># 2 * 2 = 4</span><br/>
						<span class="comment"># 2 * 3 = 6</span><br/>					
					</span>
				</code>
			</p>
			<p>
				Как и цикл <cite>while</cite>, <cite>for</cite> поддерживает ветку <cite>else</cite>. Ее работа полностью аналогична <cite>else</cite> в <cite>while</cite>.
			</p>
			<p>
				Ещё одной особенностью данного цикла является то, что можно использовать (объявлять) сразу несколько элементов в заголовке цикла и в его теле. Если мы указываем, что хотим выбирать по 3 элемента, то наша последовательность должна состоять из троек элементов (списков или кортежей):
				<code>
					<span style="color: #000000;">
						s = [(1, "one", 1.0), (2, "two", 2.0)]<br/>
						<span style="color: #0000FF;">for</span> i, j, k <span style="color: #0000FF;">in</span> s:<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(i, j, k)<br/>
						<span class="comment"># Будет выведено:</span><br/>
						<span class="comment"># 1 one 1.0</span><br/>
						<span class="comment"># 2 two 2.0</span><br/>
					</span>
				</code>
			</p>
			<p>
				Таким образом можно быстро пробежаться по ключам и значениям словаря, но для этого придётся воспользоваться его специальной функцией <cite><b>items()</b></cite>:
				<code>
					<span style="color: #000000;">
						d = {1: "one", 2: "two", 3: "three"}<br/>
						<span style="color: #0000FF;">for</span> key, value <span style="color: #0000FF;">in</span> d.items():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(key, value)	<span class="comment"># Выводим пары ключ-значение</span><br/>
						<span style="color: #0000FF;">for</span> key <span style="color: #0000FF;">in</span> d.keys():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(d[key])		<span class="comment"># Узнаём значение по ключу</span><br/>
						<span style="color: #0000FF;">for</span> value <span style="color: #0000FF;">in</span> d.values():<br/>
						&nbsp;&nbsp;&nbsp;&nbsp;print(value)<br/>
					</span>
				</code>
			</p>
			<p>
				Как и в языке C, в теле цикла можно управлять потоком выполнения. Для этого служат знакомые вам <span class="important">инструкции <b>break</b></span> и <span class="important"><b>continue</b></span>. Они могут быть использованы только в теле циклов. Инструкция <cite>break</cite> перманентно завершает выполнение текущей итерации и передаёт управление следующей за циклом строчке кода, причём блок <cite>else</cite> цикла будет проигнорирован.
			</p>
			<p>
				Инструкция <cite>continue</cite> продолжает выполнение цикла со следующей итерации. Если в теле цикла интерпретатор дойдет до инструкции <cite>continue</cite>, то выполнение текущей итерации цикла прекратится и начнется выполнение следующей (если итерация была последней, то управление перейдет ветке <cite>else</cite> цикла, если она есть, иначе выполнение цикла завершится).
			</p>
			<hr/>
			<p>
				Мы ещё вернёмся к рассмотрению алгоритмических конструкций Python в следующем уроке, когда начнём рассматривать возможности языка с точки зрения императивного программирования.
			</p>			
		</div>
		<div class="footer"></div>
	</body>
</html>
